home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / GraphView.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  12KB  |  591 lines
  1. //$GraphView,GraphNode,GraphNodeMover,GraphPath,GraphReference$
  2.  
  3. #include "ObjList.h"
  4. #include "IdDictionary.h"
  5. #include "OrdColl.h"
  6. #include "Dialog.h"
  7. #include "GraphView.h"
  8.  
  9. //---- GraphNode -------------------------------------------------------------
  10.  
  11. MetaImpl(GraphNode, (TP(constrainingNodes), TP(nonTreeOutEdges), T(inEdges), 0));
  12.  
  13. GraphNode::GraphNode(int id, Collection *cp) : TreeNode(id, cp)
  14. { 
  15.     constrainingNodes= 0; 
  16.     nonTreeOutEdges= 0;
  17.     inEdges= 0; 
  18. }
  19.  
  20. GraphNode::~GraphNode()
  21. {
  22.     SafeDelete(nonTreeOutEdges);
  23.     Object *op= Image();
  24.     if (op) {
  25.     op->FreeAll();
  26.     SafeDelete(op);
  27.     }
  28. }
  29.  
  30. VObject *GraphNode::Image()
  31. {
  32.     Collection *cp= GetList();
  33.     if (cp)
  34.     return (VObject*)(cp->At(0));
  35.     return 0;
  36. }
  37.  
  38. int GraphNode::CalcShift()
  39. {
  40.     Point origin= contentRect.origin;
  41.     
  42.     if (InCalcShift()) {
  43.     Warning("CalcShift", "cycle in graph");
  44.     return contentRect.origin.x;
  45.     }
  46.     SetFlag(eGraphInCalc);
  47.     if (!IsPositionSet()) {
  48.     SetFlag(eGraphPosSet); 
  49.     if (constrainingNodes) {
  50.         Iter next(constrainingNodes->MakeIterator());
  51.         GraphNode *gp;
  52.         while (gp= (GraphNode*)next()) 
  53.         origin.x = max(origin.x, gp->CalcShift());
  54.         //if (origin.x != contentRect.origin.x)
  55.         origin.x += 2*(Gap().x);
  56.     }
  57.     SafeDelete(constrainingNodes);
  58.     }
  59.     if (origin != contentRect.origin)
  60.     SetOrigin(origin);   
  61.         
  62.     ResetFlag(eGraphInCalc);
  63.     return contentRect.origin.x+contentRect.extent.x;
  64. }
  65.  
  66. void GraphNode::AddNonTreeOutEdge(GraphNode *gp)
  67. {
  68.     if (nonTreeOutEdges == 0)
  69.     nonTreeOutEdges= new OrdCollection;
  70.     nonTreeOutEdges->Add(gp);
  71. }
  72.  
  73. void GraphNode::AddConstrainingNode(GraphNode *gp)
  74. {
  75.     if (constrainingNodes == 0)
  76.     constrainingNodes= new OrdCollection;
  77.     constrainingNodes->Add(gp);
  78. }
  79.  
  80. void GraphNode::Draw(Rectangle r)
  81. {
  82.     Image()->DrawAll(r, FALSE);
  83. }
  84.  
  85. void GraphNode::DrawConnections()
  86. {
  87.     TreeNode::DrawConnections();
  88.     if (nonTreeOutEdges) {
  89.     VObject *image= Image();
  90.     Point p1= image->contentRect.E();
  91.     Iter next(nonTreeOutEdges);
  92.     GraphNode *gp;
  93.     while (gp= (GraphNode*)next()) 
  94.         GrLine(p1, gp->Image()->contentRect.W());
  95.     }
  96. }
  97.  
  98. void GraphNode::Export(ostream &s)
  99. {
  100.     // leave node
  101.     if ((GetList()->Size() + (nonTreeOutEdges ? nonTreeOutEdges->Size() : 0)) == 1)
  102.     return;
  103.     
  104.     GraphNode *gp;
  105.     int i= 0;
  106.     if (GetList()) {
  107.     Iter next1(GetList());
  108.     while (gp= (GraphNode*)next1()) {
  109.         if (i++ == 0) // the image of the node itself
  110.         s << gp->AsString() << ": "; 
  111.         else
  112.         s << gp->Image()->AsString() SP;
  113.     } 
  114.     } 
  115.     if (nonTreeOutEdges) {
  116.     Iter next2(nonTreeOutEdges);
  117.     while (gp= (GraphNode*)next2()) 
  118.         s << gp->Image()->AsString() SP;
  119.     }
  120.     s NL;
  121. }
  122.  
  123. //---- GraphNodeMover -------------------------------------------------------------
  124.  
  125. class GraphNodeMover: public Command {
  126.     GraphView *gvp;
  127.     GraphNode *gnp;
  128.     VObject *item;
  129.     GrCursor oldcursor;
  130.     Point delta;
  131. public:
  132.     GraphNodeMover(GraphView *g, GraphNode *v) : Command(cIdNone, "move node")
  133.     { gvp= g; gnp= v; item= gnp->Image(); delta= 0; }
  134.     void TrackFeedback(Point, Point, bool);
  135.     Command *TrackMouse(TrackPhase, Point, Point, Point);
  136.     void DoIt();
  137.     void UndoIt();
  138. };
  139.  
  140. void GraphNodeMover::TrackFeedback(Point anchorPoint, Point nextPoint, bool)
  141. {
  142.     item->Outline(nextPoint - anchorPoint);
  143. }
  144.  
  145. Command *GraphNodeMover::TrackMouse(TrackPhase tp, Point ap, Point, Point np)
  146. {
  147.     switch (tp) {
  148.     case eTrackPress:
  149.     oldcursor= GrGetCursor();
  150.     break;
  151.     case eTrackMove:
  152.     GrSetCursor(eCrsMoveHand);
  153.     break;
  154.     case eTrackRelease:
  155.     delta= np-ap;
  156.     GrSetCursor(oldcursor);
  157.     break;
  158.     default:
  159.     break;
  160.     }
  161.     return this;
  162.  
  163. }
  164.  
  165. void GraphNodeMover::DoIt()
  166. {
  167.     item->Move(delta);
  168.     gnp->contentRect+= delta;
  169.     gvp->CalcExtent();
  170.     gvp->ForceRedraw();
  171. }
  172.  
  173. void GraphNodeMover::UndoIt()
  174. {
  175.     item->Move(-delta);
  176.     gnp->contentRect-= delta;
  177.     gvp->CalcExtent();
  178.     gvp->ForceRedraw();
  179. }
  180.  
  181. //---- GraphView -----------------------------------------------------------------
  182.  
  183. MetaImpl(GraphView, (TP(nodes), TP(paths), TP(refs), 0));
  184.  
  185. GraphView::GraphView(EvtHandler *dp) : TreeView(dp)
  186. {
  187.     nodes= new IdDictionary; 
  188.     connType= eTCDiagonal;
  189.     paths= new OrdCollection;
  190.     refs= new OrdCollection;
  191. }
  192.  
  193. GraphView::~GraphView()
  194. {
  195.     nodes->FreeValues();
  196.     SafeDelete(nodes);
  197.     SafeDelete(paths);
  198.     SafeDelete(refs);
  199. }
  200.  
  201. void GraphView::Draw(Rectangle r)
  202. {
  203.     DictIterValues next(nodes);
  204.     register GraphNode *np;
  205.     
  206.     View::Draw(r);
  207.     if (connType != eTCNone)
  208.     while (np= (GraphNode*) next()) 
  209.         np->DrawConnections();
  210.     
  211.     DrawPaths(r);
  212.     DrawReferences(r);
  213.         
  214.     next.Reset();
  215.     while (np= (GraphNode*) next()) {
  216.     VObject *vp= np->Image();
  217.     if (vp && vp->contentRect.Intersects(r))
  218.         vp->DrawAll(r, vp == GetSelection());
  219.     }
  220. }
  221.  
  222. void GraphView::SetConnType(TreeConnection ct)
  223. {
  224.     if (ct != eTCNone && ct != eTCDiagonal)
  225.     return;  
  226.     connType= ct;
  227.     ForceRedraw();  
  228. }
  229.  
  230. GraphNode *GraphView::FindNode(Point lp)
  231. {
  232.     DictIterValues next(nodes);
  233.     GraphNode *np;
  234.     while (np= (GraphNode *)next()) {
  235.     VObject *vp= np->Image();
  236.     if (vp->ContainsPoint(lp))
  237.         return np;
  238.     } 
  239.     return 0;  
  240. }
  241.  
  242. Command *GraphView::DoLeftButtonDownCommand(Point lp, Token, int cl)
  243. {
  244.     GraphNode *np= FindNode(lp);
  245.     if (np)
  246.     return new TreeNodeSelector(np, cl);
  247.     return gNoChanges;  
  248. }
  249.  
  250. Command *GraphView::DoMiddleButtonDownCommand(Point lp, Token, int)
  251. {
  252.     GraphNode *np= FindNode(lp);
  253.     if (np)
  254.     return new GraphNodeMover(this, np);
  255.     return gNoChanges;  
  256. }
  257.  
  258. void GraphView::CalcExtent()
  259. {
  260.     DictIterValues next(nodes);
  261.     register GraphNode *np;
  262.     Rectangle r;
  263.     while (np= (GraphNode *)next()) 
  264.     r.Merge(np->Image()->contentRect);
  265.     SetExtent(r.extent+Point(200)); 
  266. }
  267.  
  268. Iterator *GraphView::MakeSubPartsIter(Object *)
  269. {
  270.     AbstractMethod("MakeSubPartsIter");
  271.     return 0;  
  272. }
  273.  
  274. Iterator *GraphView::MakeChildrenIter(Object *op)
  275. {
  276.     return MakeSubPartsIter(op);
  277. }
  278.  
  279. VObject *GraphView::DoCreateRoot()
  280. {
  281.     return new TextItem("Root");
  282. }
  283.  
  284. VObject *GraphView::DoCreateDialog()
  285. {
  286.     return 0;
  287. }
  288.  
  289. VObject *GraphView::AssociatedVObject(Object *op)
  290. {
  291.     GraphNode *gp= (GraphNode*) nodes->AtKey(op);
  292.     if (gp)
  293.     return gp->Image();
  294.     return 0;      
  295. }
  296.     
  297. GraphNode *GraphView::AssociatedGraphNode(Object *op)
  298. {
  299.     return (GraphNode*) nodes->AtKey(op);
  300. }
  301.  
  302. void GraphView::SetGraph(GraphNode *root, bool)
  303. {
  304.     DictIterValues next(nodes);
  305.     GraphNode *np;
  306.     
  307.     while (np= (GraphNode *)next()) {
  308.     np->SetContainer(this);
  309.     np->Enable();
  310.     }
  311.     // calculate tree layout
  312.     root->CalcExtent();
  313.     root->SetOrigin(GetOrigin());
  314.     next.Reset();
  315.     while (np= (GraphNode *)next()) 
  316.     np->CalcShift();
  317.     CalcExtent();
  318.     ForceRedraw();
  319. }
  320.  
  321. void GraphView::EmptyGraph()
  322. {
  323.     SetSelection(0);
  324.     nodes->FreeValues();
  325. }
  326.  
  327. GraphNode *GraphView::BuildGraphDFS(Object *np)
  328. {
  329.     Object *subNode;
  330.     GraphNode *gp;
  331.     
  332.     if (gp= (GraphNode*) nodes->AtKey(np)) 
  333.     return gp;
  334.     
  335.     GraphNode *node= new GraphNode;
  336.     node->AddNode(NodeAsVObject(np));
  337.     nodes->AtKeyPut(np, node); // register node in dictionary
  338.     Iterator *it= MakeSubPartsIter(np);
  339.     
  340.     if (it) {
  341.     Iter next(it);
  342.     
  343.     while (subNode= next()) {            
  344.         // node already occurred hence must be a nonTreeOutEdge
  345.         if (gp= (GraphNode*) nodes->AtKey(subNode)) { // node already occurred, -> nonTreeOutEdge
  346.         node->AddNonTreeOutEdge(gp);
  347.         gp->AddConstrainingNode(node);
  348.         } else {
  349.         gp= BuildGraphDFS(subNode);
  350.         node->AddNode(gp);
  351.         }
  352.         gp->AddInEdge(node);
  353.     }
  354.     }
  355.     return node;    
  356. }   
  357.  
  358. void GraphView::BuildGraphBFS(Object *op)
  359. {
  360.     ObjList q;          // queue for breadth first search
  361.     GraphNode *gnp, *snp;
  362.     Object *subnode, *node;
  363.     
  364.     q.Add(op);
  365.     while (q.Size() > 0) {
  366.     node= q.RemoveFirst();
  367.     if ((gnp= (GraphNode *) nodes->AtKey(node)) == 0) {
  368.         gnp= new GraphNode;
  369.         nodes->AtKeyPut(node, gnp);
  370.         gnp->AddNode(NodeAsVObject(node));
  371.     }
  372.     Iterator *it= MakeSubPartsIter(node);
  373.     if (it) {
  374.         Iter next(it);
  375.         while (subnode= next()) {
  376.         // node was already visited
  377.         if (snp= (GraphNode*)nodes->AtKey(subnode)) {
  378.             gnp->AddNonTreeOutEdge(snp);
  379.             snp->AddConstrainingNode(gnp);
  380.         } else {
  381.             snp= new GraphNode();
  382.             snp->AddNode(NodeAsVObject(subnode));
  383.             gnp->AddNode(snp);
  384.             nodes->AtKeyPut(subnode, snp);
  385.             q.Add(subnode);
  386.         }
  387.         snp->AddInEdge(gnp);
  388.         }
  389.     }
  390.     }
  391. }   
  392.  
  393. GraphNode *GraphView::FindRoot()
  394. {
  395.     OrdCollection *oc= new OrdCollection();    
  396.     DictIterValues next(nodes);
  397.     GraphNode *np, *root;
  398.  
  399.     while (np= (GraphNode *)next())
  400.     if (np->NumInEdges() == 0)
  401.         oc->Add(np);
  402.         
  403.     if (oc->Size() == 1) {
  404.     root= (GraphNode*)oc->First();
  405.     SafeDelete(oc);
  406.     return root;
  407.     }
  408.     // create artificial root
  409.     VObject *vop= DoCreateRoot();
  410.     oc->AddFirst(vop);
  411.     root= new GraphNode(cIdNone, oc);
  412.     nodes->AtKeyPut(vop, root); 
  413.     return root;
  414. }
  415.  
  416. void GraphView::DrawPaths(Rectangle r)
  417. {
  418.     Iter next(paths);
  419.     GraphPath *gp;
  420.     while (gp= (GraphPath*)next()) 
  421.     gp->Draw(r);
  422. }
  423.  
  424. void GraphView::AddPath(GraphPath *p)
  425. {
  426.     paths->Add(p);
  427.     InvalidateRect(p->BBox());
  428. }
  429.  
  430. GraphPath *GraphView::RemovePath(GraphPath *p)
  431. {
  432.     GraphPath *gp;
  433.     gp= (GraphPath*)paths->RemovePtr(p);
  434.     if (gp)
  435.     InvalidateRect(p->BBox());
  436.     return gp;
  437. }
  438.  
  439. void GraphView::RemoveAllPaths()
  440. {
  441.     paths->FreeAll();
  442.     paths->Empty(0);
  443.     ForceRedraw();
  444. }
  445.  
  446. void GraphView::DrawReferences(Rectangle r)
  447. {
  448.     Iter next(refs);
  449.     GraphReference *gp;
  450.     while (gp= (GraphReference*)next()) 
  451.     gp->Draw(r);
  452. }
  453.  
  454. void GraphView::AddReference(GraphReference *p)
  455. {
  456.     refs->Add(p);
  457.     InvalidateRect(p->BBox());
  458. }
  459.  
  460. GraphReference *GraphView::RemoveReference(GraphReference *p)
  461. {
  462.     GraphReference *gp;
  463.     gp= (GraphReference*)refs->RemovePtr(p);
  464.     if (gp)
  465.     InvalidateRect(p->BBox());
  466.     return gp;
  467. }
  468.  
  469. void GraphView::RemoveAllReferences()
  470. {
  471.     refs->FreeAll();
  472.     refs->Empty(0);
  473.     ForceRedraw();
  474. }
  475.  
  476. //---- GraphPath ------------------------------------------------------------
  477.  
  478. GraphPath::GraphPath(GraphView *g, Collection *n, Ink *i, int w, bool f)
  479. {
  480.     nodes= n;
  481.     free= f;
  482.     gvp= g;
  483.     width= w;
  484.     ink= i;
  485. }
  486.         
  487. GraphPath::~GraphPath()
  488. {
  489.     if (free)
  490.     SafeDelete(nodes);
  491. }
  492.     
  493. void GraphPath::Draw(Rectangle)
  494. {
  495.     Object *op;
  496.     VObject *image;
  497.     Iter next(nodes);
  498.  
  499.     for (int i= 0; op= next(); i++) {
  500.     image= gvp->AssociatedVObject(op);
  501.     if (!image)
  502.         continue;//Error("Draw", "node in GraphPath without representation");
  503.     GrSetPenNormal();
  504.     GrStrokeRect(image->contentRect.Expand(1));
  505.     GrSetPenSize(width);
  506.     GrSetPenPattern(ink);
  507.     if (i == 0)
  508.         GrMoveto(image->contentRect.Center());
  509.     else
  510.         GrLineto(image->contentRect.Center());
  511.     }
  512. }
  513.  
  514. Rectangle GraphPath::BBox()
  515. {
  516.     Rectangle r;
  517.     Object *op;
  518.     VObject *image;
  519.     Iter next(nodes);
  520.     while (op= next()) 
  521.     if (image= gvp->AssociatedVObject(op))
  522.         r.Merge(image->contentRect.Expand(4));
  523.     return r;
  524. }
  525.  
  526. //---- GraphReference ------------------------------------------------------------
  527.  
  528. GraphReference::GraphReference(GraphView *g, Object *op, Collection *n, Ink *i, int w, bool f)
  529. {
  530.     nodes= n;
  531.     free= f;
  532.     gvp= g;
  533.     width= w;
  534.     ink= i;
  535.     referto= op;
  536. }
  537.         
  538. GraphReference::~GraphReference()
  539. {
  540.     if (free)
  541.     SafeDelete(nodes);
  542. }
  543.     
  544. void GraphReference::Draw(Rectangle)
  545. {
  546.     Object *op;
  547.     VObject *image, *opimage;
  548.  
  549.     Iter next(nodes);
  550.     opimage= gvp->AssociatedVObject(referto);
  551.     if (!opimage)
  552.     return;
  553.     GrSetPenNormal();
  554.     GrStrokeRect(opimage->contentRect.Expand(1)); 
  555.        
  556.     for (int i= 0; op= next(); i++) {
  557.     image= gvp->AssociatedVObject(op);
  558.     if (!image)
  559.         continue;//Error("Draw", "node in GraphPath without representation");
  560.     GrSetPenNormal();
  561.     GrStrokeRect(image->contentRect.Expand(1));
  562.     DrawConnection(i, opimage, image);
  563.     }
  564. }
  565.  
  566. void GraphReference::DrawConnection(int, VObject *from, VObject *to)
  567. {
  568.     GrSetPenSize(width);
  569.     GrSetPenPattern(ink);
  570.     Point p1= from->contentRect.Center();
  571.     Point p2= to->contentRect.Center();
  572.     GrLine(p1, p2);
  573. }
  574.  
  575. Rectangle GraphReference::BBox()
  576. {
  577.     Rectangle r;
  578.     Object *op;
  579.     VObject *image, *opimage;
  580.     Iter next(nodes);
  581.   
  582.     opimage= gvp->AssociatedVObject(referto);
  583.     while (opimage && (op= next())) {
  584.     if (image= gvp->AssociatedVObject(op)) {
  585.         r.Merge(opimage->contentRect.Expand(4));
  586.         r.Merge(image->contentRect.Expand(4));
  587.     }
  588.     }
  589.     return r;
  590. }
  591.